<?
C#
=========
метод static void Main(string[] args) є таким шо по замовчуванню запускається при старті зкомпільваної проги, тобто є точкою входу в прогу
==========
на самому початку оголошуються простори імен можливо кількарівневі які будуть діяти в програмі
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
System - це вбудований простір імен який містить в собі інші простори і багато вбудованих класів які доступні з платворми дот.нет
==========
функція System.Console.ReadLine(); зчитує введені з клавіатури в консоль символи і після клавіші ентер передає програмі дані з типом string
може бути написана скорочено Console.ReadLine();
===========
функція Console.WriteLine("Variable x :" + x); виводить на екран консолі переданий їй текст і відразу переводить курсор на наступний рядок в консолі
============
void означає що функція не повертає жодного значення по завершенні її роботи
===========
клас може бути всередині відразу кількох вкладених просторів імен
namespace Сontainer{
 namespace Wrapper{
  namespace Block1{
	class ProgramDo{
		 static void Cleaner()
        {
        }
	}
  }
 }
}
тоді достyп до нього в іншому класі прописується повним шляхом Container.Wrapper.Block.ProgramDo.Cleaner()
Але має бути на початку проги прописано using Container.Wrapper.Block;
=============
Класи Інтерфейси Масиви зберігаються по посиланню в памяті процесора в кучі
Прості типи, структури зберігаються в стеку
Типи, які зберігаються в стеку і є значимими
Bool, Sbyte, Byte, Short, Ushort, Int, Uint, Long, Ulong, Float, Double, Decimal, Char, String, Object
=============
Цей цикл виведе на екран консолі цифри від 0 до 9 при цьому оператор - ; називають пустим він просто ставиться шоб цикл відбувався
for (int i =10; i<10,y>20; Console.WriteLine(i++), y--){
	;
}
Коли в циклі є лише один вираз то дужки можна взагалі забрати і прописати таким
for (int i =10; i<10,y>20; Console.WriteLine(i++), y--) ;
==============
char ch = 'A';
char ch2 = '\xC0';
char chtr= '\u0041';
перетворення букви А в цифру
int i = ch; =65  - перша буква в таблиці символів рівна цифрі 65
ch = i; видасть помилку шо неможливо конвертувати цифру в char
ch = (char) i; - отак спрацює і зконвертує цифру в букву
==============
тип char може містити тільки один символ в собі а тип string може містити і один символ і цілий текст
str = (string) ch; - видасть помилку бо тип чар неможливо напряму ковертувати в тип стрінг але можливо так
str = ch.ToString(); або  Convert.ToString(ch); або str += ch;
==============
char.IsPunctuation('-') повертає true в даному випадку - char має багато функцій
char first = 'a';
char second = 'z';
second.CompareTo(first); - видасть 25 - це різниця у відстані між символами в таблиці
=============
Console.WriteLine(@"Шлях до файлу: D:\Programs\Folder\file.txt"); знак @ - замінює екранування слешем для \
\n - новий рядок те саме шо і  - Environment.NewLine;
Console.WriteLine(Environment.MachineName); - виведе на консоль назву ПК - SERHIY-PC
Console.WriteLine(Environment.UserName); - serhiy
Console.WriteLine(Environment.OSVersion); - Microsoft Windows NT 6.1.7601 Service Pack 1
==============
Тут замість конкатенації у виразі ставиться індекс змінної яку ставимо після виразу і вона підставляється у вираз
int i = 77;
 int z = 33;
 Console.WriteLine("The price is {0} dollars and {1} cents", i,z);
  Console.ReadKey();
  - The price is 77 dollars and 33 cents

Console.WriteLine("The price is {0:C}", 99976.765); - C формат
The price is $99,976.77
Console.WriteLine("The price is {0:D7}", 99976); - можна прописати D12 - цифра вказує скільки має бути цифр в форматі
The price is 0099976 
Console.WriteLine("The price is {0:F3}", 99976);
The price is 99976.000
Console.WriteLine("The price is {0:N}", 9997634);
The price is 9,997,634.00
Console.WriteLine("The price is {0:X}", 9997634);
The price is 988D42 - шістнадцякова
==============
string s = "The weather is wonderfull";
Console.WriteLine(s.Contains('w')); --- True перевіряє чи є буква в рядку
Console.WriteLine(s.Contains(' wond')); --- True - перевірить відрізок і пробіл чи співпадають
Console.WriteLine(s.Length); - 25 - Довжина рядка разом з пробілами
Console.WriteLine(s.PadLeft(32, '!')); - Поставить 7 !-ків зліва бо довжина рядка включається в загальний рахунок
Console.WriteLine(s.Remove(3, 7)); - Видалить 7 символів починаючи з третього
Console.WriteLine(s.Replace(' ','+')); - Замінить всі пробіли на плюси - одинарні лапки це тип char тобто один символ
Console.WriteLine(s.Replace(" "," * ")); - змінить пробіли на зірочку з пробілами - подвійні лапки це тип string
s.ToUpper() s.ToLower() - переводить регістр всіх символів
string ss = string.Concat(s, " Isn't it? ", " 34343 ", s);
Console.WriteLine(ss); - The weather is wonderfull. Isn't it?  34343 The weather is wonderfull.          '/
string sss = string.Copy(s); - створить копію обєкту в кучі
Console.WriteLine(s[10]); - Виведе одну букву r -оскільки вона 10 по рахунку починаючи з нуля
string ss = string.Copy(s); 
Console.WriteLine(s == ss); - Виведе True - те саме шо і  - Console.WriteLine(s.Equals(ss));
Console.WriteLine(s.СompareTo(ss)); - Виведе 0 - бо різниці нема
===================
x = 55; y = 23;
string s = string.Format("Your age is {0}. And your seniority is {1}", x,y);
Console.WriteLine(s);
Your age is 55. And your seniority is 23
===================
  float x = 34.54f;
           float y = 25.32f; - буква f ствиться шоб був тип саме флоат а не double
   string s = string.Format("Total price is {0}.", (x+y));
            Console.WriteLine(s);
Total price is 59.86.
=================
клас stringBuilder знаходиться в просторі імен System.Text і він працює з строковими обєктами в кучі так шо вони модифікуються самі а не створюються нові
using System.Text;
StringBuilder s = new StringBuilder("Some text");
            Console.WriteLine(s.Append(" additional text")); додасть текст і виведе на консоль
Нові обєкти в кучі створюватися не будуть
Є багато інших методів
==================
В Сі шарпі всі змінні і поля по замовчуванню мають відкритість = private
Є 5 типів відкритості - private, public, protected, internal, protectedinternal
================
оголошення константи
const double somevar = 213.43;
============
type int має діапазон від -2млрд.. до +2млрд..
а unsigned від 0 до +4млрд..
================
У виразі стоїть слово checked
int x = 2435434444;
x = checked(x * 2);
воно перевіряє чи не вийде результат множення за діапазон типу якщо так то просто не виконає операцію присвоєння. Без 
цього слова викидає помилку при компіляції.
============
у виразі
i = y++;
операція інкременту буде реалізована після присвоєння
============
if(x%2 == 0) - вираз перевіряє чи нема залишку від ділення на два
умова елсіф пишеться окремо - else if(....
==============
switch(day){
case 1: 
case 2: 
case 3:
case 4: Console.Write("Any of four cases matched and passed here to write to console");
}
у даному випадку якщо буде виявлено одне з чотирьох кейс відбудеться дія №4
===============
Створення строкового масиву і проходженгня по ньому
 string[] dayofWeek = {"Monday", "Tuesday", "Wednesday"};
          
            foreach(string currDay in dayofWeek){
                Console.WriteLine(" Current day is {0}", currDay);
            }
			
==================
dayofWeek.Length - кількість елементів в масиві
==================
Створення цілочисельного  масиву
int[] arr = {10, -32, 34};
=====================
Можна взагалі створити клас і тоді по його типу масив його елементів
Animal[] {..., ..., ...};
=====================
Робота з обєктами
namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Animal Dog = new Animal();
            Animal Cat = new Animal();
            Animal Cow = new Animal();
            Dog.age = 2;
            Dog.weight = 10.5;
            Dog.height = 0.9;
            Dog.breed = "Colly";
            string Doginformation = string.Format("Dog has breed {3}:\nAge - {0} years; " + "\nWeight  {1:F3} kg; " + "\nHeight - {2:F}cm.", Dog.age, Dog.weight, Dog.height, Dog.breed);
            Console.WriteLine(Doginformation);
            Console.ReadLine();

            Cow.age = 10;
            string Cowinformation = string.Format("Cow has breed {3}:\nAge - {0} years; " + "\nWeight  {1:F3} kg; " + "\nHeight - {2:F}cm.", Cow.age, Cow.weight, Cow.height, Cow.breed);

            Console.WriteLine(Cowinformation);
            Console.ReadLine();
        }
    }

    class Animal 
    {
    public byte age;
    public double height, weight;
    public string breed;

    }
}
===================
Сортування масиву
string s = Console.ReadLine();
char[] ch = s.ToCharArray();
Array.Sort(ch);
Array.Reverse(ch);
====================
двовимірний масив
byte[,] image = new byte [ 5, 5 ];
            for (int i = 0; i < 5; i++)
            for (int j = 0; j < 5;j++ )
            image[i, j] = (byte)(i * j);

            for (int i = 0; i < 5; i++)
            {
                for (int j = 0; j < 5; j++)
                    Console.Write(image[i, j] + "\t");
                Console.WriteLine();
            }
            Console.ReadLine();
Дає таку матрицю в консолі			
0       0       0       0       0
0       1       2       3       4
0       2       4       6       8
0       3       6       9       12
0       4       8       12      16
=====================
Arrays can have more than one dimension. For example, the following declaration creates a two-dimensional array of four rows and two columns.
int[,] array = new int[4, 2];
The following declaration creates an array of three dimensions, 4, 2, and 3.
int[, ,] array1 = new int[4, 2, 3];
Array Initialization
You can initialize the array upon declaration, as is shown in the following example.
// Two-dimensional array.
int[,] array2D = new int[,] { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } };
// The same array with dimensions specified.
int[,] array2Da = new int[4, 2] { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } };
// A similar array with string elements.
string[,] array2Db = new string[3, 2] { { "one", "two" }, { "three", "four" },
                                   { "five", "six" } };
// Three-dimensional array.
int[, ,] array3D = new int[,,] { { { 1, 2, 3 }, { 4, 5, 6 } }, 
                                { { 7, 8, 9 }, { 10, 11, 12 } } };
// The same array with dimensions specified.
int[, ,] array3Da = new int[2, 2, 3] { { { 1, 2, 3 }, { 4, 5, 6 } }, 
                                       { { 7, 8, 9 }, { 10, 11, 12 } } };
// Accessing array elements.
System.Console.WriteLine(array2D[0, 0]);
System.Console.WriteLine(array2D[0, 1]);
System.Console.WriteLine(array2D[1, 0]);
System.Console.WriteLine(array2D[1, 1]);
System.Console.WriteLine(array2D[3, 0]);
System.Console.WriteLine(array2Db[1, 0]);
System.Console.WriteLine(array3Da[1, 0, 1]);
System.Console.WriteLine(array3D[1, 1, 2]);
// Output:
// 1
// 2
// 3
// 4
// 7
// three
// 8
// 12
You also can initialize the array without specifying the rank.
int[,] array4 = { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } };
If you choose to declare an array variable without initialization, you must use the new operator to assign an array to the variable. The use of new is shown in the following example.
int[,] array5;
array5 = new int[,] { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } };   // OK
//array5 = {{1,2}, {3,4}, {5,6}, {7,8}};   // Error
The following example assigns a value to a particular array element.
array5[2, 1] = 25;
Similarly, the following example gets the value of a particular array element and assigns it to variable elementValue.
int elementValue = array5[2, 1];
The following code example initializes the array elements to default values (except for jagged arrays).
int[,] array6 = new int[10, 10];
==================
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;


class Program
{
    static void Main()
    {
        // Create a three-dimensional array.
        int[, ,] threeDimensional = new int[3, 5, 4];
        threeDimensional[0, 0, 0] = 1;
        threeDimensional[0, 1, 0] = 2;
        threeDimensional[0, 2, 0] = 3;
        threeDimensional[0, 3, 0] = 4;
        threeDimensional[0, 4, 0] = 5;
        threeDimensional[1, 1, 1] = 2;
        threeDimensional[2, 2, 2] = 3;
        threeDimensional[2, 2, 3] = 4;

        // Loop over each dimension's length.
        for (int i = 0; i < threeDimensional.GetLength(2); i++)
        {
            for (int y = 0; y < threeDimensional.GetLength(1); y++)
            {
                for (int x = 0; x < threeDimensional.GetLength(0); x++)
                {
                    Console.Write(threeDimensional[x, y, i]);
                }
                Console.WriteLine();
            }
            Console.WriteLine();
        }
        Console.ReadLine();
    }
}
100
200
300
400
500

000
020
000
000
000

000
000
003
000
000

000
000
004
000
000
=======================
A jagged array is an array whose elements are arrays. The elements of a jagged array can be of different dimensions and sizes. A jagged array is sometimes called an "array of arrays." The following examples show how to declare, initialize, and access jagged arrays.
The following is a declaration of a single-dimensional array that has three elements, each of which is a single-dimensional array of integers:

int[][] jaggedArray = new int[3][];
Before you can use jaggedArray, its elements must be initialized. You can initialize the elements like this:

jaggedArray[0] = new int[5];
jaggedArray[1] = new int[4];
jaggedArray[2] = new int[2];
Each of the elements is a single-dimensional array of integers. The first element is an array of 5 integers, the second is an array of 4 integers, and the third is an array of 2 integers.
It is also possible to use initializers to fill the array elements with values, in which case you do not need the array size. For example:

jaggedArray[0] = new int[] { 1, 3, 5, 7, 9 };
jaggedArray[1] = new int[] { 0, 2, 4, 6 };
jaggedArray[2] = new int[] { 11, 22 };
You can also initialize the array upon declaration like this:

    int[][] jaggedArray2 = new int[][] 
{
    new int[] {1,3,5,7,9},
    new int[] {0,2,4,6},
    new int[] {11,22}
};
You can use the following shorthand form. Notice that you cannot omit the new operator from the elements initialization because there is no default initialization for the elements:

    int[][] jaggedArray3 = 
{
    new int[] {1,3,5,7,9},
    new int[] {0,2,4,6},
    new int[] {11,22}
};
A jagged array is an array of arrays, and therefore its elements are reference types and are initialized to null.
You can access individual array elements like these examples:

// Assign 77 to the second element ([1]) of the first array ([0]):
jaggedArray3[0][1] = 77;

// Assign 88 to the second element ([1]) of the third array ([2]):
jaggedArray3[2][1] = 88;
It is possible to mix jagged and multidimensional arrays. The following is a declaration and initialization of a single-dimensional jagged array that contains three two-dimensional array elements of different sizes. For more information about two-dimensional arrays, see Multidimensional Arrays ( Programming Guide).

int[][,] jaggedArray4 = new int[3][,] 
{
    new int[,] { {1,3}, {5,7} },
    new int[,] { {0,2}, {4,6}, {8,10} },
    new int[,] { {11,22}, {99,88}, {0,9} } 
};
You can access individual elements as shown in this example, which displays the value of the element [1,0] of the first array (value 5):

System.Console.Write("{0}", jaggedArray4[0][1, 0]);
The method Length returns the number of arrays contained in the jagged array. For example, assuming you have declared the previous array, this line:

System.Console.WriteLine(jaggedArray4.Length);
returns a value of 3.
Example
This example builds an array whose elements are themselves arrays. Each one of the array elements has a different size.

class ArrayTest
{
    static void Main()
    {
        // Declare the array of two elements: 
        int[][] arr = new int[2][];

        // Initialize the elements:
        arr[0] = new int[5] { 1, 3, 5, 7, 9 };
        arr[1] = new int[4] { 2, 4, 6, 8 };

        // Display the array elements: 
        for (int i = 0; i < arr.Length; i++)
        {
            System.Console.Write("Element({0}): ", i);

            for (int j = 0; j < arr[i].Length; j++)
            {
                System.Console.Write("{0}{1}", arr[i][j], j == (arr[i].Length - 1) ? "" : " ");
            }
            System.Console.WriteLine();            
        }
        // Keep the console window open in debug mode.
        System.Console.WriteLine("Press any key to exit.");
        System.Console.ReadKey();
    }
}
/* Output:
    Element(0): 1 3 5 7 9
    Element(1): 2 4 6 8
*/
========================================================================================================================
 тут цифрами перед дужками я позначив індексування елементів масиву. Верхній рівень це перша цифра при доступі до емеменету - Console.WriteLine(Number[1,2,3]); - тут 1, тобто другий. Друга цифра - це вкладений рівень в перший, тут це третій. І останній - це і є порядковий номер елементу всередині передостаннього, тут це четвертий. Отже
 Console.WriteLine(Number[1,2,3]);  виведе на консоль - 4444.26
 double[,,] Number = new double[2, 3, 5]
	{
            0{
		0{  12.44, 525.38,  -6.28,  2448.32, 632.04 },
        1{-378.05,  48.14, 634.18,   762.48,  83.02 },
		2{  64.92,  -7.44,  86.74,  -534.60, 386.73 }
	    },
	        1{
		0{  48.02, 120.44,   38.62,  526.82, 1704.62 },
		1{  56.85, 105.48,  363.31,  172.62,  128.48 },
		2{  906.68, 47.12, -166.07, 4444.26,  408.62 }
	    },
	};

            Console.WriteLine(Number[1,2,3]); // - 4444.26

            Console.ReadKey();
=========
Передача аргументів в функцію іншого обєкта
 class Program
    {
        static void Main(string[] args)
        {
            Calc calc = new Calc();
            int first = 3;
			int second = 2;
            Console.Write("Summ of digits is equal {0}", calc.Sum(first,second));
                       Console.ReadLine();
        }
    }
    class Calc {
        public int Sum(int firstarg, int secondarg) { 
        return firstarg+secondarg;
        }
    }
===========
Консольна програма калькулятор
 class Program
    {
        static void Main(string[] args)
        {
            Calc Calculator = new Calc();
            Calculator.Go();
            Console.ReadLine();
        }
    }
    class Calc
    {
        public void Go()
        {
            Instructions();
            Job();
        }
        void Instructions()
        {
            Console.WriteLine("'+' - adding");
            Console.WriteLine("'-' - substract");
            Console.WriteLine("'*' - multiplying");
            Console.WriteLine("'/' - dividing");
            Console.WriteLine("'^' - stepin");
            Console.WriteLine("'q' - quit");
            Console.ReadLine();
        }
        void Job()
        {
            bool isQuit = false;
            do
            {
                double i, j;
                char operation;
                Console.Write("Enter first number - ");
                i= Convert.ToDouble(Console.ReadLine());

                 Console.Write("Enter second number - ");
                j= Convert.ToDouble(Console.ReadLine());

                Console.Write("Enter operation - ");
                operation = Convert.ToChar(Console.ReadLine());

                switch (operation){
                    case '+': Console.WriteLine("{0} + {1} = {2}", i,j,(i+j)); break;
                    case '-': Console.WriteLine("{0} - {1} = {2}", i,j,(i-j)); break;
                    case '*': Console.WriteLine("{0} * {1} = {2}", i,j,(i*j)); break;
                    case '/': Console.WriteLine("{0} / {1} = {2}", i,j,(i/j)); break;
                    case '^': Console.WriteLine("{0} ^ {1} = {2}", i,j,Math.Exp(j*Math.Log(i))); break;
                    case 'q': Console.WriteLine("Good bye"); isQuit = true; break;
                    default: Instructions(); break;
                }
        
            } while(!isQuit);
           
        }
    }
=============
пряма рекурсія
class Program
    {
        static void Main(string[] args)
        {
            Recursia rec = new Recursia();
            rec.start(Convert.ToInt32(Console.ReadLine()));
            Console.ReadLine();
        }
    }
    class Recursia
    {
        int result = 1;
        public void start(int input)
        {
            result = input;
            Factorial(input);// - тут відбувається пряма рекурсивна робота функції з самою собою
            Console.WriteLine(result);
        }
        public void Factorial(int i)
        {
            if (i == 1) return;
            result *= --i; // тут іде спочатку віднімання одиниці, потім множення а потім присвоєння
            Factorial(i); // передача функцією вже зменшеної цифри на одиницю  самій собі, тобто пряма                                  рекурсія
        }
    }
====================
значення подвійного ампресанду
 class Program
    {
        static void Main()
        {
            bool x, y;
            Console.Write("Enter first data ");  //спочатку іде введення двох булев з консолі - х і у
            x = Convert.ToBoolean(Console.ReadLine());
            Console.Write("Enter second data ");
            y = Convert.ToBoolean(Console.ReadLine());
            Recursia2 rec2 = new Recursia2(); //створюємо обєкт який має два методи по роботі з булево значеннями
            if (rec2.First(x) && rec2.Second(y))// якшо стоїть два ампресанди і ми вводимо першим false то друга умова перевірена не буде, тобто не буде запущена функція rec2.Second(y). Якщо ж буде стояти один ампресанд то обидві умови будуть перевірятися за будь-яких обставин. Тому подвійний ампресанд є більш економним по ресурсах. Але інколи вигідний одинарний коли функції в умові виконують якісь додаткові дії. Те саме стосується оператора або - || - |
            { 
            
            }
            Console.WriteLine("Fin");
            Console.ReadLine();
        }
    }
    class Recursia2
    {
      public bool First(bool first)
      {
          Console.WriteLine("method first");
          return first;
      }
      public bool Second(bool second)
      {
          Console.WriteLine("method second");
          return second;
      }
    }
=====================
Область видимості змінної залежить від місця її оголошення. Якшо на початку класу оголошено то доступ до неї мають і методи і класи і цикли і будьшо. Якшо оголошено всередині методу то доступ до неї за межами методу відсутній. Якшо оголошено всередині циклу то по його завершенні змінна знищується.
Але якшо взяти окремий метод Main то для нього потрібно створювати окремо власний обєкт бо інакше він не отримує доступу до полів свого класу бо він є точкою входу програми. Хоча це не вітається і не потрібно.
 class Program
    {
        int i = 10;
        static void Main(string[] args)
        {
            Program Pr = new Program();
         Pr.i++;
        }
    }
=====================
Перегрузка методу це коли рядом в одному класі створюється два методи з одним і тим же імям але різною кількістю параметрів. І в залежності від кількості переданих аргументів буде спрацьовувати відповідний метод
public int Sum(int monday, int tuesday, int wednesday, int thursday, int friday)
    {
    return monday+tuesday+wednesday+thursday+friday;
    }
public int Sum(int monday, int tuesday, int wednesday)
    {
        return monday + tuesday + wednesday;
    }
public int Sum(int monday, int tuesday)
    {
        return monday + tuesday + wednesday;
    }
==================
Оголошення конструктора в сі шарпі проводиться оголошенням методу з таким же імям як і клас і обовязково public. 
Він запускається при створенні обєкту в методі Main чи будь-де. Його можна перегружати як любий метод в класі. Якшо вже створено один конструктор з аргументами то без аргументів перестає діяти доки ми не створимо його явно.
  class Program
    {
        static void Main(string[] args)
        {
		Work work = new Work("text sdfs", 4, "another text");
		Work work2 = new Work("text sdfs", 4);
		Work work3 = new Work();
        }
	class Work
		{
		public Work(string h, int u, string d)
		{
		Console.Write(h+" "+ u +" "+ d);
		}
		public Work(string h, int u)
		{
		Console.Write(h+" "+ u +" "+ d);
		}
		public Work()
		{
		Console.Write("Some text");
		}
		//замість любого конструктора йому можна переадресувати його на інший з аргументами шоб він запускався вже з передвстановленими аргументами. Можливою є кілька рівнева переадресація
		public Work() : this("", 1){}
		public Work(string h, int u) : this(string h, int u, "additional text"){}
		}


    }
====================
Для того шоб програма розуміла де яке Name перед полем потрібно ставити ідентифікатор this.

class Room 
{
string Name = "Gloria";
public void (string Name){
this.Name= Name;
}
}
=================
Якщо прописати в класі статичне поле(властивість)
сlass Example{
public static int i;
}
то ця властивість буде недоступна обєкту а лише класу
Example.i = 10;
Вона буде існувати до того моменту поки існує створений хоча б один обєкт цього класу. Статична властивість дає можливість обмінюватися змінною між обєктами, ажде вона одна на всі обєкти.
===================
Статичні методи можуть працювати тільки із статичними властивостями
 static void Main(string[] args)
        {
            Console.Write(Example.i);
        }
статичний конструктор оголошується без модифікатора доступу
static Example()
{

}
 Статичний конструктор викликається перед викликом основного конструктора. Він може бути викликаний при першому доступі до статичної властивості. Також він не може приймати параметри. Статичний конструктор викликається тільки один раз коли створюється перший обєкт класу далі при створенні нових обєктів він не викликається.
Статичний клас може містити тільки статичні члени, і такий клас не може бути обєктом.
 ======================
мітка для переходу назад чи вперед в коді 
loop:
some code
...
...
goto loop;
================================
В даному прикладі для того щоб змінні i , b були змінені методом public void Method( при передачі методу змінних було використано ключове слово ref, воно ж проставлене і в самому методі при його оголошенні. Дане ключове слово вказує шо іде передача не значення змінної а самої змінної по ссилці і медот всередині себе автоматом змінить зовнішні змінні i , b . Назви змінних iii  bbb не грають ніякої ролі - це внутрішні назви методу. Параметр ref може застосовуватись в одній змінній чи кількох це не суттєво. Тобто з цим параметром можна змінювати зовнішні до методу змінні не повертаючи з методу нічого.
   class Program
    {
        static void Main()
        {
           int i = 10;
            bool b = true;
            Console.WriteLine(i + ", " + b);
            Console.ReadLine();
            Work w = new Work();
            w.Method(ref i , ref b);
            Console.WriteLine(i + ", " + b);
            Console.ReadLine();
        }
    }
  
   class Work{
    public void Method(ref int iii, ref bool bbb)
        {
    iii *= 2;
    bbb = !bbb; //інвертація значення тобто буде встановлено в false
        }
            }
===========================
Коли методу передаються значення з модифікатором out то всередині методу її обовязково має бути змінено. Але змінна з модифікатором out може бути створена без початкового значення і передана методу не ініціалізованою. В решті він діє як модифікатор ref.
class Program
    {
        static void Main()
        {
            int firstArg, secondArg;
            OutMethod(out firstArg, out secondArg);
            Console.WriteLine("firsArg = {0} , secondArg = {1}", firstArg, secondArg);
            Console.ReadLine();
        }
        static void OutMethod(out int i, out int j)
        {
            i = 10;
            j = i + 1;

        }
    }
==========
Ключове слово-модифікатор передачі функції params - дає можливість не заносити попередньо в масив параметри а передати їх напряму методу, який сам їх запакує в масив. Без цього модифікатора потрібно або створити масив шоб функція прийняла або буде помилка компіляції.
При цьому кількість параметрів може бути абсолютно довільною, усі вони будуть занесені в масив.
 static void Main()
        {
           
            int rez;
            rez = Method(1,2,3,4,5,6,8,9,23);
            Console.WriteLine(rez);
            Console.ReadLine();
        }
        static int Method(params int[] mass)
        {
            int rez = 0;
            for (int i = 0; i < mass.Length; i++)
                rez += mass[i];

            return rez;

        }
===========
Структури розміщуються в стеку, а обєкти в кучі. В структурі при оголошенні полів заносити туда значення не дозволено.
Змінні структури безпосередньо містять їх в стеку.
  class Program
    {
        static void Main(string[] args)
        {
            Points point;
            point.x = 10;
            point.y = 20;
            Console.WriteLine(point.x + " " + point.y);
            Console.ReadLine();
        }
    }
    struct Points
    { 
    public int x;
    public int y;
    }
=============================================================PRINTED===================================================
Метод Cost має внутрішні автоматичні методи get i set для роботи з одною властивістю класу з перевіркою перед вставленням і роботою на виведення приватної властивості. Цей метод дає можливість інкапсулювати приватну властивість cost і працює з нею в викликаючому класі. Шоб вручну не прописувати цей метод в візуалСтудіо можна виділити поле - клікнути правю кнопкою миші - Refactor - Encapsulate Field. Можна видалити або set або get таким чином обмежити роботу з приватною властивістю.
class Program
    {
        static void Main()
        {
            Commodity coffee = new Commodity();
            coffee.Cost = 12.45f;
            Console.WriteLine(coffee.Cost);
            Console.ReadLine();
        }
    }
    class Commodity
    {
        private float cost;

        public float Cost
        {
            get { return cost; }
            set { 
                if(value>0&&value<100)
                cost = value; }
        }
    }
==============
Двокрапка в цьому записі те саме шо в php - extends, тобто функціонал класу First копіюється в клас  Second. В класі Second  будуть доступні методи і властивості з доступом public назовні i protected всередині класу , private не успадковуються взагалі. 
class First
    {
      public int i;
      protected string s;
      private bool f;
      public void MethodFirst()
      {
          i++;
      }
    }
    class Second: First
    {
        public void MethodSecond()
        {
            i++;
        }
    }
==================
В даному прикладі створюється обєкт класу SportCar який розширяє клас Car. При цьому конструктору SportCar передається 5 даних, 3 з яких приймає конструктор класу Car, а в конструкторі SportCar прописана передача в свій конструктор 3-х даних з класу Car -  : base(color, weight, power).
class Program
    {
        static void Main()
        {
            SportCar SC = new SportCar("green", 2000, 250, 7, true);
            Console.WriteLine(SC.color + " " + SC.weight + " " + SC.power + " " + SC.transmission 
                + " " + SC.complete_drive);
            Console.ReadLine();
        }
    }
    class Car
    {
        public string color;
        public int weight;
        public int power;
          public Car(string color, int weight, int power)
        {
            this.color = color;
            this.weight = weight;
            this.power = power;
        }
    }
    class SportCar : Car
    {
        public short transmission;
        public bool complete_drive;
        public SportCar(string color, int weight, int power, short transmission, bool complete_drive)
            : base(color, weight, power)
        {
            this.transmission = transmission;
            this.complete_drive = complete_drive;
        }
    }
=============
Тут основне це доступ до властивості включеного обєкту через оцей вираз - car.Zapas.pressure. Тобто тут Zapas - це доступ до властивостей включеного класу Zapaska. 
class Program
    {
        static void Main()
        {
            Car car = new Car();
            Console.WriteLine(car.PressureInWheels + " ");
            car.PumpingWheels();
            Console.ReadLine();
            Console.WriteLine(car.PressureInWheels + " ");
            Console.ReadLine();
            Console.WriteLine(car.Zapas.pressure + " ");
            Console.ReadLine();     
        }
    }
    class Zapaska
    {
        public byte diameter;
        public short pressure;
        public Zapaska()
        {
            diameter = 30;
            pressure = 2000;
    }
        public void Pumping(short pressure)
        {
            this.pressure = pressure;
        }
    }
    class Car
    {
        Zapaska zapaska = new Zapaska();
        short pressureinWheels;
        public void PumpingWheels()
        {
            pressureinWheels = 2200;
            zapaska.Pumping(2100);
        }
        public Zapaska Zapas
        {
            get { return zapaska; }
            set { zapaska = value; }
        }
        public short PressureInWheels
        {
            get { return pressureinWheels; }
        }
    }
===================
Інший варіант використання класу Zapaska це його оголошення всередині класу Car. І тоді його обєкт тиру Car.Zapaska можна створити в методі Main, але лише якшо перед оголошеним класом стояло public. В іншому випадку створення обєкту буде можливим лише в класі контейнері Car. 
 class Program
    {
        static void Main()
        {
            Car car = new Car();
            Car.Zapaska zapas = new Car.Zapaska();
            zapas.diameter = 12;
    
        }
    } 
    class Car
    {
        public class Zapaska
        {
            public byte diameter;
            public short pressure;
            public Zapaska()
            {
                diameter = 30;
                pressure = 2000;
            }
            public void Pumping(short pressure)
            {
                this.pressure = pressure;
            }

        }     
        short pressureinWheels;
        public void PumpingWheels()
        {
            pressureinWheels = 2200;
               }
               public short PressureInWheels
        {
            get { return pressureinWheels; }
        }
    }
============
Реалізація поліморфізму, можливість створення в класі-нащадку методу який перезаписує базовий
public virtual void Square()
{

}
Якщо стоїть модифікатор virtual в базовому класі то клас-нащадок може але не зобовязаний його переопреділити в своєму оголошенні
public override void Square()
{
base.Square(); // - це запуск базового методу
}
=================================================PRINTED======================================
Boxing
Implicit conversion of a value type (int, char etc.) to a reference type (object), is known as Boxing. In boxing process, a value type is being allocated on the heap rather than the stack.
Unboxing
Explicit conversion of same reference type (which is being created by boxing process); back to a value type is known as unboxing. In unboxing process, boxed value type is unboxed from the heap and assigned to a value type which is being allocated on the stack.

Boxing - Unboxing
int i = 10;
ArrayList arrlst = new ArrayList();
 //ArrayList contains object type value
//So, int i is being created on heap
arrlst.Add(i); // Boxing occurs automatically
 
int j = (int)arrlst[0]; // Unboxing occurs
===========
Всі типи в сі шарп успадковуються від типу Object. Це значить шо можливе неявне перетворення в цей тип будь-якого іншого:
			Object o = new NewType();
            Object oo = new int();
            Object ooo = new string('f',2);
====================
В масиві батьківського типу ми можемо зберігати обєкти типів які успадковують цей тип
namespace Nasliduvannya
{
    class Program
    {
        static void Main()
        {
            A a = new B();
            object[] mass = new object[] {new A(), new B(), new int(), new object(), new bool()};
           

		   B b = new B();
            C c = new C();
            D d = new D();
            b.x = 10;
            c.x = 20;
            d.x = 30;
            A[] massaa = new A[] {b,c,d};
            for(int i=0; i<massaa.Length; i++)
            {
            Console.WriteLine(massaa[i].ToString() + " " + massaa[i].x);
            Console.ReadLine();
            }
        }
		static void Method(A input)
		{
		Console.WriteLine(input.ToString());
            Console.ReadLine();
		}
    }
    class A
    {
        public int x;
    }
    class B: A
    {

    }
    class C : A
    { 
    
    }
    class D : A
    {

    }
}
=================
if(inp is SomeType)
{
Console.ReadLine();
}
тут перевірка чи передана наприклад в функцію змінна inp має тип SomeType
Ключовим словом є is
================
inp as SomeType
тут повертається посилання на обєкт типу SomeType
=========
Тут в класі B метод ShowInfo() оголошується з ключовим словом new для того шоб не було конфлікту з одноіменним методом в класі А. Це саме слово буде працювати і з властивостями  - public new string info;
class Program
    {
        static void Main(string[] args)
        {
		B b = new B("bbbbbb");
            b.ShowInfo();        //задіюється метод ShowInfo() класу B
            ((A)b).ShowInfo();	 //задіюється метод ShowInfo() класу А бо до його типу приводиться змінна	
        }
    }
 class A
    {
        protected string info;
        public A(string info)
        {
            this.info = info;
        }
        public void ShowInfo()
        {
            Console.WriteLine(this.info);
            Console.ReadLine();
        }
    }
    class B : A
    {
         public B(string info) : base(info)
        {
            this.info = info;
        }
        public new void ShowInfo()
        {
            Console.WriteLine("B byaka " + info);
            Console.ReadLine();
        }
    }
===============
Один з варіантів заборонити створення обєкту класу, якшо він наприклад служить тільки для батьківських цілей - це оголосити його конструктор з модифікатором доступу protected ( бо private не дасть створити і дочірній обєкт). Але це спосіб застарілий. Простішим методом є оголошення класу з ключовим словом abstract, а конструктор класу тоді може бути public .
abstract class Figure 
{
public Figure()
{

}
//так само можна створити абстрактний метод який не буде виконуватись але він обовязково має бути перезаписаний в дочірньому класі
public abstract void Square(); //!!!!фігурний дужок не ставиться
//абстрактні методи можуть бути лише в абстрактних класах
}
================
Якщо в батьківському класі оголосити метод з ключовим словом sealed то нащадки цього класу не успадкують цей метод.
public sealed void Method()
{

}
так само можна запечатати від успадкування і клас
sealed class Ego
{

}
===============
Інтерфейси потрібно називати з великої букви І. Кожен член інтерфейсу має public доступ і є abstract-ними, тому як і в абстрактного класу в інтерфейсу не може бути створено власного обєкту.
interface IRun 
{
int X
{
get;
set;
}
bool running;
}
class Car: IRun
{
public int X
{
get{return x;}
set{x = value;};
}
bool running = true;
}
============
В типі базового класу можна зберігати обєкт класу нащадка, але тоді ця змінна із типом класу батька не буде мати методи і поля нащадка а лише базові. І навпаки обєкт створений по типу самого себе має усі властивості і методи батьківських абстрактних класів чи інтерфейсів.
================
Інтерфейси можуть успадковувати одне одного
interface A
{
public void methodA(){}
}
interface B
{
public void methodB(){}
}
//тут клікнути можна по А чи В правою кнопкою і вибрати в контекстному меню Implement Interface - Implement Interface - вставиться усі методи і властивості інтерфейсу в клас
class AB: A, B 
{
#region A Members

        public void methodA()
        {
            throw new NotImplementedException();
        }

        #endregion

        #region B Members

        public void methodB()
        {
            throw new NotImplementedException();
        }

        #endregion
}
можливо просто прописати пряме успадкування кількох інтерфейсів іншим:
interface B:А, С, D 
{

}
тоді не треба буде вже далі успадковувати класи А, С, D  достатньо буде класу В
=============
Метод System.Equals(car, car2); - буде перевіряти не тотожність двох обєктів, бо якшо ці змінні ведуть на два обєкти в кучі то буде повернене false навіть якшо ці обєкти абосолютно одинакові. А true буде повернене лише тоді коли ці дві змінні є одинаковим посиланнями, тобто ведуть на один обєкт в кучі.
Цей метод може бути перезаписаний через ключове слово override в любому класі. 
Може викликатися наступним чином
car.Equals(car2);
===========
Всередині методу Console.WriteLine(); по хамовчуванню викликається метод ToString()
його можна перегрузити в класі шоб більш ширше працював
public override string ToString()
{
string info;
info = String.Format("name = {0}, price = {1}",name, price);
return info;
}
тоді цей метод в якомусь класі може бути наприклад викликаний так 
Console.WriteLine(car.ToString());
Метод Equals() також можна перекривати всередині класу
public override bool Equals(object input)
{
	if(input!=null && input is Car)
	{
		if(this.ToString() == input.ToString())
		{
		return true;
		}
	}
	 return false;
}
Вбудований в платформу метод GetHashCode(); дає різні хешкоди для двох обєктів одного класу, його теж можна перекривати в класі
public override int GetHashCode()
{
return this.ToString().GetHashCode();
}
===============================PRINTED======================================================
Копіювання екземплярів структур робить два незалежні один від одного обєкти
class Program
    {
        static void Main(string[] args)
        {
            SomeStruct SS1 = new SomeStruct(100, true);
            SomeStruct SS2 = SS1;//структури є значимого типу і тому при копіюванні повністю копіюються поля і методи 
            //як і в інших значимих типів - bool, int..
            SS1.i = 0;
            SS1.flag = !SS1.flag; //false
            Console.WriteLine("SS1.i = {0}, SS1.flag = {1}", SS1.i, SS1.flag);
            // дані було зкопійовано і тому в першій структурі буде змінено дані а в другій ні
            Console.WriteLine("SS2.i = {0}, SS2.flag = {1}", SS2.i, SS2.flag);
            Console.ReadLine();
        }
    }
	 //якшо натиснути на назві структури SomeStruct і в контектному меню перейти по Refactor-Rename то можна змінити імя по всьому скрипту відразу
    struct SomeStruct   
    {
        public int i;
        public bool flag;
        public SomeStruct(int i, bool flag)
        {
            this.i = i;
            this.flag = flag;
        }
    }
======================
Копіювання екземплярів класів створює два абсолютно ідентичні посилання на один і той же обєкт
namespace Clon
{
    class Program
    {
        static void Main(string[] args)
        {
            SomeClass SS1 = new SomeClass(100, true);
            SomeClass SS2 = SS1;//класи є силочного типу і тому при копіюванні їх обєктів копіюється тільки посилання на один і той же обєкт, сам обєкт залишається одним
            SS1.i = 0;
            SS1.flag = !SS1.flag; //false
            Console.WriteLine("SS1.i = {0}, SS1.flag = {1}", SS1.i, SS1.flag);
            // дані не було зкопійовано і тому буде змінено дані в обох обєктах класу SS1 і SS2
            Console.WriteLine("SS2.i = {0}, SS2.flag = {1}", SS2.i, SS2.flag);
            Console.ReadLine();
        }
    }
    class SomeClass
    {
        public int i;
        public bool flag;
        public SomeClass(int i, bool flag)
        {
            this.i = i;
            this.flag = flag;
        }
    }
}
==================
Якщо потрібно повністю зкопіювати обєкт, так шоб він був незалежним від першого потрібно прописати інтерфейс при створенні класу 
class SomeClass: ICloneable
далі клікнути правоб по ньому і вибрати Implement Inerface - Implement Inerface
зявиться метод Clone() який потрібно прописати самому
class SomeClass: ICloneable
    {
        public int i;
        public bool flag;
        public SomeClass(int i, bool flag)
        {
            this.i = i;
            this.flag = flag;
        }
        public object Clone()
        {
            return new SomeClass(this.i,this.flag);
        }  
    }
і тоді в методі Main копіювання прописується так
SomeClass SS2 = (SomeClass)SS1.Clone();
це дасть нам повністю незалежний обєкт
================
сортування масиву прізвищ учнів
namespace ConsoleApplication13
{
    class Program
    {
        static void Main(string[] args)
        {
		//занесення в масив studetsName
            string[] studetsName = new string[]
            {
            "Alexander Gudok",
            "Stanislav Velchik",
            "Malinochka Olga",
            "Solomka Ludmila",
            "Dmitri Vorotniuk",
            "Stanislav Velchik",
            "Dmitri Vorotniuks",
            "Violetta Jankovich",
            "Karpenko Daria",
            "Alena Mankovska"
            };
			//створення масиву обєктів типу Student 
            Student[] jornal = new Student[studetsName.Length];
            for (int i = 0; i < jornal.Length; i++ )
            {
                jornal[i] = new Student(i+1, studetsName[i]);
            }
			//сортування масиву з обєктами. шоб цей метод працював потрібно в клас Student бо ми сортуємо тут цей тип,  додати інтерфейс IComparable. Мануал пише про Array.Sort так - This member is overloaded. For complete information about this member, including syntax, usage, and examples, click a name in the overload list. І в цьому списку є метод IComparable. В ВізуалСтудіо стандартно тиснемо на ньому правою і вибираємо Implement Inerface двічі зявиться метод  IComparable.CompareTo() . Тобто коли в процесі роботи Array.Sort іде порівняння одного елементу масиву до іншого викликається метод IComparable.CompareTo().
            Array.Sort(jornal);
             for (int i = 0; i < jornal.Length; i++ )
            {
                jornal[i].number = i + 1;
                Console.WriteLine(jornal[i].number + " -> " + jornal[i].name); 
            }
            Console.ReadLine();
           
        }
    }
    class Student: IComparable
    {
        public int number;
        public string name;
        public Student(int number, string name)
        {
            this.name = name;
            this.number = number;
        }
		//тут this - це обєкт який сортується зараз як основний в методі Array.Sort(), а temp(input) це черговий обєкт який підставляється для порівняння.
        int IComparable.CompareTo(object input)
        {
            Student temp = (Student)input;
			//довжина імені студента
            int Length;
			//тут іде вибір більшої довжини
            if (this.name.Length > temp.name.Length)
                Length = temp.name.Length;
            else
                Length = this.name.Length;
				//тут в циклі іде порівняння кожної букви
            for (int i = 0; i < Length; i++ )
            {
			//тут якшо темп має меншу букву то він має сортуватися нижче головного і тому повертаємо 1
                if(this.name[i] > temp.name[i])
                    return 1;
			//тут навпаки
                if (this.name[i] < temp.name[i])
                    return -1;
			//тут іде порівняння на останній букві довжини слів
                if (i == (Length - 1))
                {
				//якщо довжина слова головного менша за підставний то підставний опускається в сортуванні на 1 
                    if (this.name.Length < temp.name.Length)
                        return -1;
				//якщо довжина слова головного більша за підставний то підставний піднімається в сортуванні на 1 
                    if (this.name.Length > temp.name.Length)
                    return 1;
					//якщо було 100% співпадіння двох порівнюваних обєктів то нічого не сортується
                    if (this.name.Length == temp.name.Length)
                        return 0;
                }
            }
			//якщо було 100% співпадіння двох порівнюваних обєктів
            return 0;          
          
        }

         }
}
=============
робота з масивом з допомогою вбудованого класу ArrayList

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
//підключення простору імен шоб працював клас ArrayList
using System.Collections;

namespace ConsoleApplication14
{
    class Program
    {
        static void Main(string[] args)
        {
            //створення обєкту info класу ArrayList
            ArrayList info = new ArrayList();
            string temp;
            
            do
            {
                Console.WriteLine("Do you have the infomation?");
				//якщо не було натиснуто ентер без внесення даних
                if ((temp = Console.ReadLine()) != "")
             // почергово вставляє елемент в масив       
                    info.Add(temp);
              //закінчується цикл і процес внесення даних
				else
                    break;
            }
            while (temp != "");
            //- AddRange додає масив в свій обєкт
            info.AddRange(new string[] { "ddfgd", "fsfsdfs", "dgdfgdfgd" });
            //Insert - вставляє елемент в масив під інексом номер 3
            info.Insert(3, "text in number 3 position");
            //вивід на екран усіх елементів
            for (int i = 0; i < info.Count;i++ )
                Console.WriteLine("Current information - " + info[i]);
            //вивід розміру масиву
             Console.WriteLine(info.Count);
            Console.ReadLine();
                  }
    }
}
====================
Обробка помилок
  class Program
    {
        static void Main(string[] args)
        {
            byte i = 0;
            int x = 0;
            //створюємо власний обєкт для виведення помилки типу переповнення стеку, в лапках конструктору обєкта передається властивість Message

            OverflowException ovEx = new OverflowException("Remember you cant put the integer bigger than 255");
            //задаємо власне посилання на сайт допомоги
            ovEx.HelpLink = "http://msdn.microsoft.com/en-us/library/system.overflowexception(v=vs.110).aspx";
            //зчитування вводу користувача. Якшо ввести наприклад 278 то буде помилка бо це вже перевищує розмір типу byte
            try
            {
                Console.WriteLine("Enter i please");
                i = byte.Parse(Console.ReadLine());
                
                Console.WriteLine("Enter x please");
                x = int.Parse(Console.ReadLine());
                //для ікса ми генеруємо виведення вмісту блоку catch для OverflowException при перевірці заданої умови
                if (x > 255)
                    throw ovEx;
            }
            //блок catch запускаться тільки коли було знайдено помилку. Тут FormatException і будь який інший типізований блок catch має йти перед основним блоком catch, який має йти вкінці інакше буде помилка компіляції.
            //FormatException - це перевірка чи введено правильний формат даних в даному випадку byte
            catch (FormatException e)
            {
                Console.WriteLine("Uneligble format");
                //ця властивіть виводить дані про помилку
                Console.WriteLine(e.TargetSite);
                //виведе стек визовів причому найперший той шо зверху буде відповідати тому шо викликав помилку
                Console.WriteLine("\r\n"+ e.StackTrace);
                //виведе посилання на інтернет-сторінку допомоги яку програміст має задати самостійно
                Console.WriteLine("\r\n" + e.HelpLink);

            }
            // помилка переповнення стеку
            catch (OverflowException e)
            {
                Console.WriteLine("Uneligble value. StackOverFlow");
                Console.WriteLine("Go to help page - " + e.HelpLink);
                Console.WriteLine("\r\n" + e.Message);
            }
            //основний блок 
            catch
            {
                Console.WriteLine("Unexpectable value");
            }

                //блок finally виконується завжди незалежно від того знайдено помилку чи ні
            finally
            {
                Console.WriteLine("Block finally is being executable anytime");
                if (i == 0)
                    i = 1;
            }
            Console.ReadLine();
            Console.WriteLine("i = " + i);
            Console.ReadLine();
        }
    }
=============
Робота з індексованим масивом
using System;
using System.Linq;
using System.Text;
using System.Collections;

namespace ConsoleApplication16
{
    class Program
    {
        static void Main(string[] args)
        {
		//занесення в масив studetsName
            string[] abiturients = new string[]
            {
            "Alexander Gudok",
            "Stanislav Velchik",
            "Malinochka Olga",
            "Solomka Ludmila",
            "Dmitri Vorotniuk",
            "Stanislav Velchik",
            "Dmitri Vorotniuks",
            "Violetta Jankovich",
            "Karpenko Daria",
            "Alena Mankovska"
            };
            Journal journ = new Journal();
            for(int i =0; i<abiturients.Length;i++)
                journ[i]= new Student(i+1,abiturients[i]);
		 for(int i =0; i<journ.Length;i++)
             Console.WriteLine(journ[i].Number + " -> " + journ[i].Name);
        
            Console.ReadLine();
    }
    class Student
    {
        public int number;
        public string name;
        public Student(int number, string name)
        {
            this.name = name;
            this.number = number;
        }
        public int Number
        {
        get{return number;}
            set{
            if(value>0&& value<30)
                number = value;
            }
        }
        public string Name
        {
        get{return name;}
            set{
                if(value.Length>0&&value.Length<51)
           name = value;
            }
        }


         }
    class Journal
    { 
        
    ArrayList journal = new ArrayList();

        //створення індексів для масиву типу Journal
        public Student this[int index]
        {
        get{return (Student)journal[index];}
            set{
                if(index > -1 && (value is Student))
            journal.Add(value);

            }
        }
        //втсановлюємо власну властивість для індексатора, хоча це явний маразм бо можна просто використати journal.Count
        public int Length
        {
            get { return journal.Count; }
          
        }
    }
}
}
==============================PRINTED=======================
перегрузка операторів
    class Program
    {
        static void Main()
        {
            int i =10;
            int y = 20;
            string s = "some string";
            string ss = "!";
            //тут плюс працює як додавання
            int x = i + y;
            //тут плюс працює як зєднання
            string sss = ss + s;

            Point p1 = new Point(10,20);
            Point p2 = new Point(30, 40);

            Point p3 = new Point(0, 0);
            //досить багато коду для додавання властивостей, для спрощення нам потрібно буде пперегрузити оператор + в класі Point
            p3.x = p1.x + p2.x;
            p3.y = p1.y + p2.y;
            //після перегрузки ми можемо пропиcати операцію просто як
            p3 = p1 + p2;

            Console.WriteLine(p3.x + " " + p3.y);
            Console.ReadLine();
            //застосування перегруженого оператора інкременту
            p3 = ++p3;

            Console.WriteLine(p3.x + " " + p3.y);
            Console.ReadLine();
            //використання перегруженого оператора рівності - видасть false
            Console.WriteLine(p1 == p2);
            Console.ReadLine();

        }
    }
    class Point
    {
        public int x;
        public int y;
        public Point(int i, int j)
        {
            x = i;
            y = j;
        }
        //перегрузка оператора + для конкретного типу Point, для всіх решти типів оператор + буде працювати так як звичайний оператор додавання. Так можна перегружати і інші оператори * \ -
        public static Point operator +(Point p1, Point p2)
        {
            return new Point(p1.x + p2.x, p1.y + p2.y);
        }
        //для оператора інкременту трошки інакший спосіб перегрузки, вхідний параметр тільки один
        public static Point operator ++ (Point p)
        {
            return new Point(p.x + 1, p.y + 1);
        }
        //шоб перегрузити оператор рівності = потрібно початку перегрузити метод Equals
        public override bool Equals(object input)
        {
            if (input is Point)
            {
                if (((Point)input).x == this.x && ((Point)input).y == this.y)
                    return true;
            }
            return false;
        }
        public override int GetHashCode()
        {
            return this.ToString().GetHashCode();
        }
        //сама перегрузка
        public static bool operator ==(Point p1, Point p2)
        {
            return p1.Equals(p2);
        }
        public static bool operator !=(Point p1, Point p2)
        {
            return !p1.Equals(p2);
        }
    }
===========================
using System;
using System.Collections; //це потрібно шоб працювало SortedList
using System.Linq;
using System.Text;
using System.Reflection;
class Program
{
    static void Main()
    {
        //тип Type дає доступ до інформації про клас і його методи
        Type t = Type.GetType("SomeClass");
        ShowMetadata(t);
    }
    static void ShowMetadata(Type t)
    {
        SortedList classInfo = new SortedList();
        if (t.IsAbstract)
            classInfo["isAbstract"] = "isAbstract";
        else
            classInfo["isAbstract"] = "isNotAbstract";


        if (t.IsValueType)
            classInfo["IsValueType"] = "IsValueType";
        else
            classInfo["IsValueType"] = "IsNotValueType";

        classInfo["baseType"] = t.BaseType.ToString();

        Console.WriteLine("Class" + t.Name + ": \n  Abstract = {0}, \n Value Type = {1},\n Base type ={2} \n and have next memebers",
            classInfo["isAbstract"], classInfo["IsValueType"], classInfo["baseType"]);      

        FieldInfo[] F = t.GetFields();
        foreach (FieldInfo info in F)
            Console.WriteLine(info.Name);       

        PropertyInfo[] P = t.GetProperties();
        foreach (PropertyInfo info in P)
            Console.WriteLine(info.Name); //виведе Iii
      
        MethodInfo[] M = t.GetMethods();
        foreach (MethodInfo info in M)
            Console.WriteLine(info.Name);
       
        /*виведе get_Iii
              set_Iii
            SomeMethod
            ToString
            Equals
            GetHashCode
            GetType*/

        Type[] I = t.GetInterfaces();
        foreach (Type info in I)
            Console.WriteLine(info.Name);//виведе ISomeInterface
        Console.ReadKey();

    }
}
interface ISomeInterface
{
    string SomeMethod(bool flag);
}
class BaseClass
{
    public bool flag;
}

class SomeClass : BaseClass, ISomeInterface
{
    int iii;

    public int Iii
    {
        get { return iii; }
        set { iii = value; }
    }
    public string SomeMethod(bool flag)
    {
        return flag.ToString();
    }
}
==========
права кнопка по назві проекту і Add Reference - там можна додавати бібліотеки класів, наприклад вбудовані на вкладці .Net, користувацькі на Projects
Шоб створити нову бібліотеку потрібно натиснути New-Project-Class Library
Шоб зформувалися файли бвблвотеки потрібно натиснути Build-Build Solution
Бібліотеку неможливо запустити бо там нема навіть точки входу Main вона і не потрібна
Далі тиснемо папку жовту шоб відкрити бібліотеку, далі переходимо в папку bin-Debug і копіюємо там файл бібліотеки з розширенням .dll, далі шоб вставити в проект зкопійовану бібліотеку відкриваємо проект, тиснемо Build-Build Solution, переходимо в папку bin-Debug проекту і вставляємо туда наш зкопійований файл. Тепер шоб підключити дану бібліотеку треба задати на неї посилання через права кнопка на назві проекту - Add Reference - Browse-bin-Debug. Після цього можна в проекті створити обєкт бібліотечного класу ClassLibrary2.MyClass MyClass = new ClassLibrary2.MyClass();  і потім викликати його метод  MyClass.MyMethod(true, "some string", 343);
namespace ConsoleApplication12
{
    class Program
    {
        static void Main(string[] args)
        {
            ClassLibrary2.MyClass MyClass= new ClassLibrary2.MyClass();
            MyClass.MyMethod(true, "some string", 343);
            
        }
    }
}
// інший файл
namespace ClassLibrary2
{
    public class MyClass
    {
        public void MyMethod(bool flag, string input, int count) {
            if (!flag) return;
            else
                for (int i = 0; i < count; i++)
                    Console.WriteLine(input);
            Console.ReadLine();
        }
    }
}
=================PRINTED=================================
виклик приватного методу в обхід його закритості
using System;
//підключаємо простір імен рефлексії
using System.Reflection;

 class Program
    {
        static void Main(string[] args)
        {
            SomeClass sc = new SomeClass();
			//з допомогою рефлексії отримуємо тип нашого класу
            Type t = sc.GetType();
			// отримуємо тип нашого методу вказавши два флаги
            MethodInfo mi = t.GetMethod("Method",BindingFlags.Instance|BindingFlags.NonPublic);
			//власне викликаємо закритий метод
            mi.Invoke(sc, null);
        }
    }
    class SomeClass {
        void Method() {
            Console.WriteLine("Works private method");
            Console.ReadKey();
        }
    }
============
ArrayList якшо шось додає в свій масив то по-любому конвертує в тип обєкт, а List дає можливість задати тип динамічного масиву, і тому операція упаковки/розпаковки типів не потрібна. List працює лише при підключеному просторі імен System.Collections.Generic
 class Program
    {
        static void Main(string[] args)
        {
		//задаємо строгий тип даного масиву при його створенні
            List<byte> mass = new List<byte>();
			//додаємо туди число яке конвертується в тип byte, якшо спробувати велике число видасть помилку бо цей тип не підтримує великих чисел
            mass.Add(100);
			//приклад передачі даних з масиву в змінну
            byte x = mass[100];
//створюємо масив типу власного класу куда можуть бути додані лише обєкти класу SomeClass 
            List<SomeClass> massUser = new List<SomeClass>();
            massUser.Add(new SomeClass());
             
        }
    }
    class SomeClass
    { 
    }
==============
Узагальнений метод
   class Program
    {
        static void Main()
        {
            Method(5, 10);
            Method("drgerge", "dsfgdgfdg");
        }
        //узагальнений метод може бути і public і протектед він дає можливість передавати методу параметри різних типів і компілятор підставляє їх в функцію без помилок. Перша буква Т вимагає підстановки типу який буде повернено з методу через return, якщо б функція була без параметрів то тоді треба прописувати визов методу отак  Method<int>(); шоб компілятор знав який тип має повертати метод. Якщо ж передаються параметри то тип поверненого значення компілятор визначяає по них і спеціально прописувати його не потрібно.
        static T Method<T>(T x, T y)
        {
            Console.WriteLine(x + " and " + y);
            Console.ReadLine();
            return x;
        }
    }
	По аналогії створюється узагальнений клас синтаксис якого можна найти в неті.
==========
Делегати
namespace Delegat
{
    //оголошення делегату який за нашим визначення може викликати методи лише які повертають стрінгове значення а приймають два параметри інт і бул. Делегат це сутність класу
    delegate string Del(int x, bool y);
    delegate void DelStat(ref int x);

    class Program
    {
        static void Main(string[] args)
        {
            Someclass SC = new Someclass();
            //передаємо делегату назву методу який делегат буде викликати
            Del del = new Del(SC.Method);
            //виклик методу SC.Method з параметрами 
            string s = del(10, true);
            Console.WriteLine(s);
            Console.ReadLine();
            
            
              //передаємо делегату назву методу який делегат буде викликати
            DelStat delstat = new DelStat(Someclass.MethodStat);
            //виклик методу SC.Method з параметрами 
            int p = 50;
            delstat(ref p);
            Console.WriteLine(p);
            Console.ReadLine();
            
        }
    }
}
class Someclass {
    public string Method(int x, bool flag)
    {
        return string.Format(x.ToString() + " " + flag.ToString());
    }
    public static void MethodStat(ref int x)
    {
        x *= x;
    }
}
=============
Мультизапуск методів з допомогою делегатів
namespace Delegate
{
    //створення делегату для методу без параметрів
    delegate void Delegat();
    class Program
    {
        static void Main(string[] args)
        {
            //обєкт делегату і реєстрація методу М1
            Delegat del = new Delegat(M1);
            //реєстрація в делегаті методу М2
            del += M2;
            //знову реєстрація делегату методу М1 який спрацює два рази
            del += M1;
            //Зняття з реєстрації методу М2 і він взагалі не зпрацює
            del -= M2;
            //виклик відразу два рази методу М1
            del();
            //запуск делегату з іншого методу
            MDel(del);
        }
        static void M1()
        {
            Console.WriteLine("This method is M1");
        }
        static void M2()
        {
            Console.WriteLine("This method is M2");
        }
        static void MDel(Delegat d)
        {
            d();
        }
    }
}
===============
Події
namespace Event
{
    /* Порядок роботи з подією:
     * 1 - оголосити делегат який задає сигнатуру методу
     * 2 - оголосити подію типу делегату
     * 3 - зареєструвати на подію якийсь метод який відповідає сигнатурі методу делегпту
     * 4 - виконати подію
    */

    //голошуємо делегат як правило за межами класу
    delegate void PushPrinterButton();
    
    class Program
    {
        static void Main(string[] args)
        {
            //створюємо обєкт класу Mouse
            Mouse mouse = new Mouse();
            //реєструємся на подію з вказанням конкретного методу
            mouse.Click += new PushPrinterButton(onmouseclick);
            mouse.Click += new PushPrinterButton(onmouseclick2);
            
            //відміна першого обробника події 
            mouse.Click -= new PushPrinterButton(onmouseclick);
            mouse.doevent();
        }
        //метод який зпрацює коли станеться подія
        static void onmouseclick()
        {
            Console.WriteLine("mouse button was pressed to print the text. Starts process...");
            Console.ReadKey();
        }
        //інший обробник події. Взагалі обробник події може бути в будь-якому класі
        static void onmouseclick2()
        {
            Console.WriteLine("wait while process is working...");
            Console.ReadKey();
        }
    }
    
    class Mouse
    {
        //оголошення події
        public event PushPrinterButton Click; //оголосили подію натиснення кнопки миші

       

        public void doevent() // генерація події
        {
            if (Click != null)
            Click(); //запуск події
        }
    }
}

================
програмка по використанню обробки подій
namespace Event_app
{
    delegate void PushPrinterButton();
    class Program
    {
        static void Main(string[] args)
        {
            PrintButton printbutton = new PrintButton();
            printbutton.Click += new PushPrinterButton(StartPrint.printClick);
            Console.WriteLine("Enter text");
            Console.CancelKeyPress +=new ConsoleCancelEventHandler(Console_CancelKeyPress);
            while (true)
            {
                string temp = Console.ReadLine();
                if(temp!="")
                {
                    StartPrint.text += temp + "\n";
                    continue;
            }
                break;
            }
            while (true)
            {
                if (Console.ReadLine() == "p")
                {
                    printbutton.doEvent();
                    break;

                }
                            }

        }
        static void Console_CancelKeyPress(object sender, ConsoleCancelEventArgs e)
        {
            Console.WriteLine("\a\a\a\a\a");
        }
    }
    class StartPrint
    {
        public static string text;
        public static void printClick()
        {
            Console.WriteLine("Get your text " + text);
        }

    }
    class PrintButton
    {
        public event PushPrinterButton Click;
        public void doEvent()
        {
            if (Click != null)
            {
                Click();
            }
        }
    }
}
============
приклад оброблення події
namespace ConsoleApplication23
{
    //оголошення делегату типу ChangeStatus який приймає стрінгове значення
    delegate void ChangeStatus(string message);
    class Program
    {
        static void Main(string[] args)
        {
            Corvet FirstCar = new Corvet();
            FirstCar.ChangePrice += new ChangeStatus(FirstCar_ChangePrice);

            Console.WriteLine("Set new price");
            FirstCar.Price = Int32.Parse(Console.ReadLine());
            Console.ReadKey();
        }
        //обробник події який запускається для події ChangePrice
        static void FirstCar_ChangePrice(string message)
        {
            Console.WriteLine(message);
        }
    }
    class Corvet {
        //цін на автомобідь
        int price;
        //створення користувацької події типу делегату
        public event ChangeStatus ChangePrice;
        //властивість для відкритого доступу до прайс
        public int Price {
            get { return price; }
            set { if (value > 0) price = value;
                //при встановленні нової ціни генеруємо подію
            if (ChangePrice != null) { ChangePrice("Price is changed to: " + this.price); }
            }
        }
    }
}
==========
//цей простір імен потрібний для нормальної роботи багатопотокового коду
using System.Threading;


namespace Primer
{
    class Program
    {
        static void Main()
        {
            //запуск потоку з методом BooolMethod і чекаємо на результат на екрані нам виведе два рази 
            //виведе flag = false тому що ці змінні створюються в двох потоках і є незалежними тому і на старті одинаковими а по коду ніби мало би змінитися на тру. Але якшо метод BooolMethod прописати як статік - static BooolMethod - то змінна flag буде видна для двох потоків відразу і зіниться при виводі на екран на true.
            Thread newBooolThread = new Thread(BooolMethod);
            //запуск нового потоку
            newBooolThread.Start();
            BooolMethod();
            Console.ReadLine();

            //створення потоку
            Thread newThread = new Thread(SomeMethod);
            //запуск нового потоку
            newThread.Start();
            Console.ReadLine();

            //запуск анонімного методу тобто такого шо буде працювати лише в конкретному потоці. назву ми цьому методі не вказуємо
            Thread newOneThread = new Thread(delegate() { Console.WriteLine("Working a second thread"); });
            //запуск нового потоку
            newOneThread.Start();
            Console.ReadLine();

            //зпрощений варіант синтаксису запуску анонімного методу 
            new Thread(delegate() { Console.WriteLine("Working a third thread"); }).Start();
            Console.ReadLine();

            //запуск потоку з методом JustMethod
            Thread newJustThread = new Thread(JustMethod);
            //запуск нового потоку
            newJustThread.Start();
            //виводимо ше одні цифри в безкінечному циклі шоб показати як  потоки працюють в парі - а саме позмінно а не одночасно
            for (int j = 0; ; j++)
            {
                Console.WriteLine("j = " + j + "\n");
            }
        }

        static void SomeMethod()
        {
            Console.WriteLine("Working a new thread");
        }
        //метод безкінечного виводу цифр
        static void JustMethod()
        {
            for (int i = 0; ; i++)
            { Console.WriteLine("\t\t i = {0}", i); }

        }
        static void BooolMethod()
        {
            //затримка на 0.5 секунди коду
            Thread.Sleep(500);
            //ключове слово lock забезпечує виконання коду в фігурних дужках як єдиного оператора - це означає шо коли іде два потоки то блок лок буде виконано нерозривно без переключання на інший поток
            lock("text")
            {
                bool flag = false;
                Console.WriteLine("flag = {0}", flag);
                flag = !flag;
            }
            //можна використоати замість lock клас Monitor, цей клас має ше кілька додаткових методів
            Monitor.Enter("finish");
            try
            {
                bool flag = false;
                Console.WriteLine("flag = {0}", flag);
                flag = !flag;
            }
            finally
            {
               // Monitor.Exit("good bye");
            }
        }
    }
}
===============PRINTED=================
Є два головних види потоків процесів - фонові і переднього плану. Метод Main при запуску програми розміщається в потік переднього плану. Метод .Start() також створює потік переднього плану. Причиною зависання програми при виході з нього може бути незавершення одного з потоків переднього плану. Фонові потоки це некритичні процеси які при вимкненні голоних потоків автоматично закриваються навіть якшо їх методи не виконані. 
Приклад пріоритету головного і фонового потоків
class Program
    {
	//запускається поток головного плану для методу Main
        static void Main()
        {
		//стоврення потоку thread і передача йому методу Method з безкінечним циклом 
            Thread thread = new Thread(Method);
			//перетворення потоку thread в фоновий тобто другорядний
            thread.IsBackground = true;
			//старт потоку thread
                        thread.Start();
						//по ідеї ніби поток має тривати безкінечно але він знаходиться всередині головного потоку методу Main який не гальмуючи доходить до кінця і закриває консольне вікно тобто безкінечний цикл обривається
   
        }
        static void Method()
        {
            while (true)
            {
                Thread.Sleep(250);
                Console.Write("!");
            }

        }
    }
=================
Передача параметрів в метод потоку 
   class Program
    {
        static void Main()
        {
		//Створення потоку для методу який прийме параметром обєкт
            Thread t = new Thread(new ParameterizedThreadStart(Method));
			//створення обєкту який буде параметром для методу і сам при створенні вимагає два параметри в свій конструктор
            All all = new All(10, " number 9 ");
			//запуск потоку із передачею обєкту як параметру для методу Method
            t.Start(all);
   
        }
        static void Method(object o)
        {
            All all = o as All;
            for (int i = 0; i < all.i; i++ )
            {
                Thread.Sleep(1000);
                Console.WriteLine(all.s + "  "); 
            }
        }
      
    }

    class All
    {
        public int i;
        public string s;
        public All(int i, string s)
        {
            this.i = i;
            this.s = s;
        }
    
    }
===================
partial class Form1 - означає шо цей клас оголошено в двох файлах і з двох кусків він буде потім становити одне ціле.
=====================
Файл Program.cs містить в собі метод Main і цей метод змінювати для форм аплікейшн нема чого він існує для запуску решти коду. Тут в цьому методі є таке
//створення обєкту класу програми і передача його методу ран класу аплікейшн
            Application.Run(new Form1());
=======================
Порядок роботи з подіями це відкрити форми файлу Form1.cs а потім ше і відкрити його код правою кнопкою по назві і вибрати Show code. В файлі Form1.cs клікнути по елементу наприклад кнопці потім зправа перейти на випадну панель Properties і там натиснути зверху кнопку events у вигляді блискавки. Далі вибрати подію і натиснути на ній два рази після чого студія відразу перейде до коду цієї події.
=========================
Кнопки події панельки
файл Form1.cs
using System.Windows.Forms;

namespace FirstWindowsFormsApplication
{
    public partial class Form1 : Form
    {
        string s;
        public Form1()
        {
            InitializeComponent();
            Control.ControlCollection cc = this.Controls;
              foreach (Control control in cc)
        s += control.Text + " ";

        MessageBox.Show(s);
        }
       private void Form1_Load(object sender, EventArgs e)
        {
this.Text += "!!!!";
        }
        private void first_button_click(object sender, EventArgs e)
        {
              Knopka.Enabled = !Knopka.Enabled;
              //MainPanel.Visible = !MainPanel.Visible;
       }
        private void second_buton_click(object sender, EventArgs e)
        {
            Knopka.Text = "I was pressed";
            Knopka.Size = new Size(Knopka.Size.Width+25, Knopka.Size.Height);
        }
        private void Form1_MouseClick(object sender, MouseEventArgs e)
        {
            if(e.Button == MouseButtons.Left)
            MessageBox.Show("The left mouse button was pressed");
            else if (e.Button == MouseButtons.Right)
                MessageBox.Show("The right mouse button was pressed");
            else 
                MessageBox.Show("The middle mouse button was pressed");
        }

        private void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
           DialogResult dr = MessageBox.Show("Are you sure you want to leave application", "Close Application", MessageBoxButtons.YesNoCancel);
           if (dr == DialogResult.Yes)
               e.Cancel = false;
           else
               e.Cancel = true;
        }

        private void OffButton_Click(object sender, EventArgs e)
        {
            MainPanel.Enabled = !MainPanel.Enabled;
        } 
    }
}
 файл Form1.Designer.cs
 namespace FirstWindowsFormsApplication
{
    partial class Form1
    {
        /// <summary>
        /// Required designer variable.
        /// </summary>
        private System.ComponentModel.IContainer components = null;

        /// <summary>
        /// Clean up any resources being used.
        /// </summary>
        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
        protected override void Dispose(bool disposing)
        {
            if (disposing && (components != null))
            {
                components.Dispose();
            }
            base.Dispose(disposing);
        }

        #region Windows Form Designer generated code

        /// <summary>
        /// Required method for Designer support - do not modify
        /// the contents of this method with the code editor.
        /// </summary>
        private void InitializeComponent()
        {
            this.Knopka = new System.Windows.Forms.Button();
            this.button1 = new System.Windows.Forms.Button();
            this.MainPanel = new System.Windows.Forms.Panel();
            this.OffButton = new System.Windows.Forms.Button();
            this.textBox1 = new System.Windows.Forms.TextBox();
            this.MainPanel.SuspendLayout();
            this.SuspendLayout();
            // 
            // Knopka
            // 
            this.Knopka.ForeColor = System.Drawing.Color.Maroon;
            this.Knopka.Location = new System.Drawing.Point(44, 169);
            this.Knopka.Name = "Knopka";
            this.Knopka.Size = new System.Drawing.Size(144, 59);
            this.Knopka.TabIndex = 0;
            this.Knopka.Text = "Click me";
            this.Knopka.UseVisualStyleBackColor = true;
            this.Knopka.Click += new System.EventHandler(this.second_buton_click);
            // 
            // button1
            // 
            this.button1.Location = new System.Drawing.Point(34, 25);
            this.button1.Name = "button1";
            this.button1.Size = new System.Drawing.Size(154, 37);
            this.button1.TabIndex = 1;
            this.button1.Text = "Do not click me anyway";
            this.button1.UseVisualStyleBackColor = true;
            this.button1.Click += new System.EventHandler(this.first_button_click);
            // 
            // MainPanel
            // 
            this.MainPanel.AutoScroll = true;
            this.MainPanel.BackColor = System.Drawing.SystemColors.HotTrack;
            this.MainPanel.BorderStyle = System.Windows.Forms.BorderStyle.Fixed3D;
            this.MainPanel.Controls.Add(this.button1);
            this.MainPanel.Controls.Add(this.Knopka);
            this.MainPanel.Location = new System.Drawing.Point(12, 12);
            this.MainPanel.Name = "MainPanel";
            this.MainPanel.Size = new System.Drawing.Size(333, 194);
            this.MainPanel.TabIndex = 2;
            // 
            // OffButton
            // 
            this.OffButton.Location = new System.Drawing.Point(470, 24);
            this.OffButton.Name = "OffButton";
            this.OffButton.Size = new System.Drawing.Size(154, 37);
            this.OffButton.TabIndex = 3;
            this.OffButton.Text = "OffButton";
            this.OffButton.UseVisualStyleBackColor = true;
            this.OffButton.Click += new System.EventHandler(this.OffButton_Click);
            // 
            // textBox1
            // 
            this.textBox1.Location = new System.Drawing.Point(453, 142);
            this.textBox1.Multiline = true;
            this.textBox1.Name = "textBox1";
            this.textBox1.Size = new System.Drawing.Size(171, 84);
            this.textBox1.TabIndex = 4;
            // 
            // Form1
            // 
            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
            this.ClientSize = new System.Drawing.Size(662, 282);
            this.Controls.Add(this.textBox1);
            this.Controls.Add(this.OffButton);
            this.Controls.Add(this.MainPanel);
            this.Name = "Form1";
            this.Text = "Form1 Forever";
            this.Load += new System.EventHandler(this.Form1_Load);
            this.MouseClick += new System.Windows.Forms.MouseEventHandler(this.Form1_MouseClick);
            this.FormClosing += new System.Windows.Forms.FormClosingEventHandler(this.Form1_FormClosing);
            this.MainPanel.ResumeLayout(false);
            this.ResumeLayout(false);
            this.PerformLayout();

        }

        #endregion

        private System.Windows.Forms.Button Knopka;
        private System.Windows.Forms.Button button1;
        private System.Windows.Forms.Panel MainPanel;
        private System.Windows.Forms.Button OffButton;
        private System.Windows.Forms.TextBox textBox1;
	
		
    }
}
=======================














?>
